home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / IATHREAD.PAK / IATHREAD.C < prev    next >
C/C++ Source or Header  |  1997-05-06  |  16KB  |  570 lines
  1. // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  2. // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  3. // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  4. // PARTICULAR PURPOSE.
  5. //
  6. // Copyright (C) 1993-1995  Microsoft Corporation.  All Rights Reserved.
  7. //
  8. //  MODULE:   iathread.c
  9. //
  10. //  PURPOSE:  Implement the window procedure for the main application
  11. //            window.
  12. //
  13. //  FUNCTIONS:
  14. //    FrameWndProc      - Processes messages for the main window.
  15. //    MsgCommand        - Handle the WM_COMMAND messages for the main window.
  16. //    MsgCreate         - To create the MDI client window.
  17. //    MsgClose          - Handles the WM_CLOSE message.
  18. //    MsgDestroy        - Handles the WM_DESTROY message.
  19. //    CmdForwardToActiveChild - Forwards a WM_COMMAND message to the active
  20. //                              MDI child window.
  21. //    CmdFileNew        - To create a new mdi child window.
  22. //    CmdFileClose      - To close the active mdi child window    
  23. //    CmdFileExit       - Handles the file exit command by calling destory 
  24. //                        window on the main window.
  25. //    CmdWindowTile     - To tile the mdi child windows.
  26. //    CmdWindowCascade  - To cascade the mdi child windows.
  27. //    CmdWindowIcons    - To arrage the mdi child icons.
  28. //    CmdWindowCloseAll - To close all of the mdi child windows.
  29. //
  30. //  COMMENTS:
  31. //    Message dispatch table -
  32. //      For every message to be handled by the main window procedure
  33. //      place the message number and handler function pointer in
  34. //      rgmsd (the message dispatch table).  Place the prototype
  35. //      for the function in globals.h and the definition of the
  36. //      function in the appropriate module.
  37. //    Command dispatch table -
  38. //      For every command to be handled by the main window procedure
  39. //      place the command number and handler function pointer in
  40. //      rgcmd (the command dispatch table).  Place the prototype
  41. //      for the function in globals.h and the definition of the
  42. //      function in the appropriate module.
  43. //    Globals.h Contains the definitions of the structures and dispatch.c
  44. //      contains the functions that use these structures.
  45. //
  46.  
  47. #include <windows.h>            // required for all Windows applications
  48. #include <windowsx.h>
  49. #include "globals.h"            // prototypes specific to this application
  50. #include "resource.h"
  51.  
  52.  
  53. // Main window message table definition.
  54. static MSD rgmsd[] =
  55. {
  56.     {WM_COMMAND,    MsgCommand},
  57.     {WM_CREATE,     MsgCreate},
  58.     {WM_CLOSE,      MsgClose},
  59.     {WM_DESTROY,    MsgDestroy}
  60. };
  61.  
  62. static MSDI msdiMain =
  63. {
  64.     sizeof(rgmsd) / sizeof(MSD),
  65.     rgmsd,
  66.     edwpMDIFrame
  67. };
  68.  
  69.  
  70. // Main window command table definition.
  71. static CMD rgcmd[] =
  72. {
  73.     {IDM_FILE_NEW,          CmdFileNew},
  74.     {IDM_FILE_CLOSE,        CmdFileClose},
  75.     {IDM_FILE_EXIT,         CmdFileExit},
  76.     {IDM_THREAD_PRIORITY,   CmdForwardToActiveChild},
  77.     {IDM_THREAD_SUSPEND,    CmdForwardToActiveChild},
  78.     {IDM_THREAD_RESUME,     CmdForwardToActiveChild},
  79.     {IDM_WINDOW_TILE,       CmdWindowTile},
  80.     {IDM_WINDOW_CASCADE,    CmdWindowCascade},
  81.     {IDM_WINDOW_ICONS,      CmdWindowIcons},
  82.     {IDM_WINDOW_CLOSEALL,   CmdWindowCloseAll},
  83.     {IDM_HELP_ABOUT,        CmdAbout}
  84.  
  85. };
  86.  
  87. static CMDI cmdiMain =
  88. {
  89.     sizeof(rgcmd) / sizeof(CMD),
  90.     rgcmd,
  91.     edwpMDIFrame
  92. };
  93.  
  94.  
  95. // Global variable definitions
  96.  
  97. UINT gcOpenChildWnds = 0;         // Number of child windows open.
  98.  
  99.  
  100. //
  101. //  FUNCTION: FrameWndProc(HWND, UINT, WPARAM, LPARAM)
  102. //
  103. //  PURPOSE:  Processes messages for the main window.
  104. //
  105. //  PARAMETERS:
  106. //    hwnd     - window handle
  107. //    uMessage - message number
  108. //    wparam   - additional information (dependent on message number)
  109. //    lparam   - additional information (dependent on message number)
  110. //
  111. //  RETURN VALUE:
  112. //    The return value depends on the message number.  If the message
  113. //    is implemented in the message dispatch table, the return value is
  114. //    the value returned by the message handling function.  Otherwise,
  115. //    the return value is the value returned by the default window procedure.
  116. //
  117. //  COMMENTS:
  118. //    Call the DispMessage() function with the main window's message dispatch
  119. //    information (msdiMain) and the message specific information.
  120. //
  121.  
  122. LRESULT CALLBACK FrameWndProc(HWND   hwnd, 
  123.                               UINT   uMessage, 
  124.                               WPARAM wparam, 
  125.                               LPARAM lparam)
  126. {
  127.     return DispMessage(&msdiMain, hwnd, uMessage, wparam, lparam);
  128. }
  129.  
  130.  
  131. //
  132. //  FUNCTION: MsgCommand(HWND, UINT, WPARAM, LPARAM)
  133. //
  134. //  PURPOSE: Handle the WM_COMMAND messages for the main window.
  135. //
  136. //  PARAMETERS:
  137. //    hwnd      - window handle
  138. //    uMessage  - WM_COMMAND (Unused)
  139. //    wParam    - Message-specific parameter.
  140. //    lParam    - Message-specific parameter.
  141. //
  142. //  RETURN VALUE:
  143. //    The return value depends on the command number.  If the command
  144. //    is implemented in the command dispatch table, the return value is
  145. //    the value returned by the command handling function.  Otherwise,
  146. //    the return value is the value returned by the default window procedure.
  147. //
  148. //  COMMENTS:
  149. //    Call the DispCommand() function with the main window's command dispatch
  150. //    information (cmdiMain) and the command specific information.
  151. //
  152.  
  153. #pragma argsused
  154. LRESULT MsgCommand(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  155. {
  156.     return DispCommand(&cmdiMain, hwnd, wparam, lparam);
  157. }
  158.  
  159.  
  160. //
  161. //  FUNCTION: MsgCreate(HWND, UINT, WPARAM, LPARAM)
  162. //
  163. //  PURPOSE: To create an MDI client window.
  164. //
  165. //  PARAMETERS:
  166. //    hwnd     - The window handing the message.
  167. //    uMessage - WM_CREATE             (unused)
  168. //    wparam   - Message specific data (unused).
  169. //    lparam   - Message specific data (unused).
  170. //
  171. //  RETURN VALUE:
  172. //    Always returns 0 - message handled.
  173. //
  174. //  COMMENTS:
  175. //
  176. //
  177.  
  178. #pragma argsused
  179. LRESULT MsgCreate(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  180. {
  181.     CLIENTCREATESTRUCT ccs;
  182.  
  183.     // Find window menu where children will be listed
  184.     ccs.hWindowMenu  = GetSubMenu(GetMenu(hwnd), INITWINDOWMENU);
  185.     ccs.idFirstChild = IDW_FIRST_CHILD;
  186.  
  187.     // Create the MDI client filling the client area
  188.     ghwndMDIClient = CreateWindow("mdiclient",
  189.                                              NULL,
  190.                                   WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL |
  191.                                   WS_HSCROLL |WS_VISIBLE,
  192.                                   0, 0, 0, 0,
  193.                                   hwnd,
  194.                                   (HMENU)IDW_MDICLIENT,
  195.                                   hInst,
  196.                                   (LPSTR)&ccs);
  197.  
  198.     // If client window couldn't be created, signal failure.
  199.     if (ghwndMDIClient == NULL)
  200.         return -1;
  201.  
  202.      return 0;
  203. }
  204.  
  205.  
  206. //
  207. //  FUNCTION: MsgClose(HWND, UINT, WPARAM, LPARAM)
  208. //
  209. //  PURPOSE: 
  210. //
  211. //  PARAMETERS:
  212. //
  213. //    hwnd      - Window handle  (Unused)
  214. //    uMessage  - Message number (Unused)
  215. //    wparam    - Extra data     (Unused)
  216. //    lparam    - Extra data     (Unused)
  217. //
  218. //  RETURN VALUE:
  219. //
  220. //    Always returns 0 - Message handled
  221. //
  222. //  COMMENTS:
  223. //
  224. //
  225.  
  226. #pragma argsused
  227. LRESULT MsgClose(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  228. {
  229.     // Destroy unattached menu.
  230.     if (GetMenu(hwnd) == ghInitMenu)
  231.         DestroyMenu(ghDocMenu);
  232.     else
  233.         DestroyMenu(ghInitMenu);
  234.    
  235.      DestroyWindow(hwnd);
  236.     return 0;
  237. }
  238.  
  239.  
  240. //
  241. //  FUNCTION: MsgDestroy(HWND, UINT, WPARAM, LPARAM)
  242. //
  243. //  PURPOSE: Calls PostQuitMessage().
  244. //
  245. //  PARAMETERS:
  246. //
  247. //    hwnd      - Window handle  (Unused)
  248. //    uMessage  - Message number (Unused)
  249. //    wparam    - Extra data     (Unused)
  250. //    lparam    - Extra data     (Unused)
  251. //
  252. //  RETURN VALUE:
  253. //
  254. //    Always returns 0 - Message handled
  255. //
  256. //  COMMENTS:
  257. //
  258. //
  259.  
  260. #pragma argsused
  261. LRESULT MsgDestroy(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  262. {
  263.     PostQuitMessage(0);
  264.     return 0;
  265. }
  266.  
  267.  
  268. //
  269. //  FUNCTION: CmdForwardToActiveChild(HWND, WORD, WORD, HWND)
  270. //
  271. //  PURPOSE: To forward a command to the active MDI child window.
  272. //
  273. //  PARAMETERS:
  274. //    hwnd      - The window handling the command.
  275. //    wCommand  - Depends on command.
  276. //    wNotify   - Notification number.
  277. //    hwndCtrl  - NULL.
  278. //
  279. //  RETURN VALUE:                         
  280. //    Always returns 0 - command handled.
  281. //
  282. //  COMMENTS:
  283. //
  284. //
  285.  
  286. #pragma argsused
  287. LRESULT CmdForwardToActiveChild(HWND hwnd, WORD wCommand, WORD wNotify,
  288.                                 HWND hwndCtrl)
  289. {
  290.      HWND hChildWnd;
  291.  
  292.      // Ask the MDI client to tell us which child window is active.  If there
  293.      // is an active child window, forward the message; otherwise, don't.
  294.      hChildWnd = (HWND)SendMessage(ghwndMDIClient, WM_MDIGETACTIVE, 0, 0);
  295.  
  296.      if (IsWindow(hChildWnd))
  297.           SendMessage(hChildWnd,
  298.                     WM_COMMAND, 
  299.                     GET_WM_COMMAND_MPS(wCommand, hwndCtrl, wNotify));
  300.     return 0;
  301. }
  302.  
  303.  
  304. //
  305. //  FUNCTION: CmdFileNew(HWND, WORD, WORD, HWND)
  306. //
  307. //  PURPOSE: To create a new mdi child window.
  308. //
  309. //  PARAMETERS:
  310. //    hwnd      - The window handling the command.
  311. //    wCommand  - IDM_FILE_NEW        (unused)
  312. //    wNotify   - Notification number (unused)
  313. //    hwndCtrl  - NULL                (unused).
  314. //
  315. //  RETURN VALUE:
  316. //    Always returns 0 - command handled.
  317. //
  318. //  COMMENTS:
  319. //
  320. //
  321.  
  322. #pragma argsused
  323. LRESULT CmdFileNew(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  324. {
  325.     static int      snChildWndNum = 0;
  326.      MDICREATESTRUCT mcs           = {0};
  327.      HWND            hwndChild;
  328.     char            szTitle[DEFAULT_STR_LEN];
  329.     char            szChildName[DEFAULT_STR_LEN];
  330.     DWORD           dwVersion;
  331.  
  332.     // Reset child window # if no child windows exist
  333.      if (gcOpenChildWnds == 0)
  334.         snChildWndNum = 0;
  335.  
  336.     LoadString(hInst, IDS_CHILDNAME, szChildName, sizeof(szChildName));
  337.     wsprintf(szTitle, "Thread Window %d", snChildWndNum);
  338.  
  339.     // Windows NT and Windows 95 present different options for creating
  340.     // an MDI child window.  While using the WM_MDICREATE message will
  341.     // work on both Windows versions, Windows 95 presents a new window
  342.     // style which simplifies the process.  Here the function uses the
  343.     // method apropriate for the system it's running on.
  344.  
  345.     dwVersion = GetVersion();
  346.     if ((dwVersion < 0x80000000) || (LOBYTE(LOWORD(dwVersion)) < 4))
  347.     {
  348.         // This is Windows NT or Win32s, so use the WM_MDICREATE message
  349.  
  350.           mcs.szClass = szChildName;      // window class name
  351.         mcs.szTitle = szTitle;          // window title
  352.           mcs.hOwner  = hInst;            // owner
  353.         mcs.x       = CW_USEDEFAULT;    // x position
  354.         mcs.y       = CW_USEDEFAULT;    // y position
  355.         mcs.cx      = CW_USEDEFAULT;    // width
  356.         mcs.cy      = CW_USEDEFAULT;    // height
  357.         mcs.style   = 0;                // window style
  358.         mcs.lParam  = 0;                // lparam
  359.  
  360.         hwndChild = (HWND) SendMessage(ghwndMDIClient,
  361.                                        WM_MDICREATE,
  362.                                        0,
  363.                                                     (LPARAM)(LPMDICREATESTRUCT) &mcs);
  364.      }
  365.      else
  366.      {
  367.           // This method will only work with Windows 95, not Windows NT or Win32s
  368.           hwndChild = CreateWindowEx(WS_EX_MDICHILD,  // EX window style
  369.                                               szChildName,     // window class name
  370.                                               szTitle,         // window title
  371.                                               0,               // window style
  372.                                               CW_USEDEFAULT,   // x position
  373.                                               CW_USEDEFAULT,   // y position
  374.                                               CW_USEDEFAULT,   // width
  375.                                               CW_USEDEFAULT,   // height
  376.                                               ghwndMDIClient,  // parent
  377.                                               NULL,            // menu (child ID)
  378.                                               hInst,           // owner
  379.                                               0);              // lparam
  380.      }
  381.  
  382.      if (hwndChild != NULL)
  383.      {
  384.           ShowWindow(hwndChild, SW_SHOW);
  385.         snChildWndNum++;
  386.     }
  387.  
  388.     return 0;
  389. }
  390.  
  391.  
  392. //
  393. //  FUNCTION: CmdFileClose(HWND, WORD, WORD, HWND)
  394. //
  395. //  PURPOSE: To close the active MDI child window.
  396. //
  397. //  PARAMETERS:
  398. //    hwnd      - The window handling the command.
  399. //    wCommand  - IDM_FILE_CLOSE      (unused).
  400. //    wNotify   - Notification number (unused)
  401. //    hwndCtrl  - NULL                (unused).
  402. //
  403. //  RETURN VALUE:
  404. //    Always returns 0 - command handled.
  405. //
  406. //  COMMENTS:
  407. //
  408. //
  409.  
  410. #pragma argsused
  411. LRESULT CmdFileClose(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  412. {
  413.     HWND hwndActive;
  414.  
  415.     // Ask the MDI client window which MDI child window is active.  If 
  416.     // there is an active child window, destroy it; otherwise, do nothing.
  417.  
  418.     hwndActive = (HWND)SendMessage(ghwndMDIClient, WM_MDIGETACTIVE, 0, 0);
  419.     if (hwndActive != NULL)
  420.         SendMessage(ghwndMDIClient, WM_MDIDESTROY, (WPARAM)hwndActive, 0);
  421.  
  422.     return 0;
  423. }
  424.  
  425.  
  426. //
  427. //  FUNCTION: CmdFileExit(HWND, WORD, WORD, HWND)
  428. //
  429. //  PURPOSE: Exit the application.
  430. //
  431. //  PARAMETERS:
  432. //    hwnd     - The window handling the command.
  433. //    wCommand - IDM_FILE_EXIT       (unused)
  434. //    wNotify  - Notification number (unused)
  435. //    hwndCtrl - NULL                (unused)
  436. //
  437. //  RETURN VALUE:
  438. //    Always returns 0 - command handled.
  439. //
  440. //  COMMENTS:
  441. //
  442. //
  443.  
  444. #pragma argsused
  445. LRESULT CmdFileExit(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  446. {
  447.      SendMessage(hwnd, WM_CLOSE, 0, 0L);
  448.      return 0;
  449. }
  450.  
  451.  
  452. //
  453. //  FUNCTION: CmdWindowTile(HWND, WORD, WORD, HWND)
  454. //
  455. //  PURPOSE: To tile the mdi child windows.
  456. //
  457. //  PARAMETERS:
  458. //    hwnd      - The window handling the command.
  459. //    wCommand  - IDM_WINDOW_TILE     (unused).
  460. //    wNotify   - Notification number (unused)
  461. //    hwndCtrl  - NULL                (unused).
  462. //
  463. //  RETURN VALUE:
  464. //    Always returns 0 - command handled.
  465. //
  466. //  COMMENTS:
  467. //
  468. //
  469.  
  470. #pragma argsused
  471. LRESULT CmdWindowTile(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  472. {
  473.      SendMessage(ghwndMDIClient, WM_MDITILE, 0, 0);
  474.  
  475.     return 0;
  476. }
  477.  
  478. //
  479. //  FUNCTION: CmdWindowCascade(HWND, WORD, WORD, HWND)
  480. //
  481. //  PURPOSE: To cascade the mdi child windows.
  482. //
  483. //  PARAMETERS:
  484. //    hwnd      - The window handling the command.
  485. //    wCommand  - IDM_WINDOW_CASCADE  (unused).
  486. //    wNotify   - Notification number (unused)
  487. //    hwndCtrl  - NULL                (unused).
  488. //
  489. //  RETURN VALUE:
  490. //    Always returns 0 - command handled.
  491. //
  492. //  COMMENTS:
  493. //
  494. //
  495.  
  496. #pragma argsused
  497. LRESULT CmdWindowCascade(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  498. {
  499.      SendMessage(ghwndMDIClient, WM_MDICASCADE, 0, 0);
  500.  
  501.     return 0;
  502. }
  503.  
  504. //
  505. //  FUNCTION: CmdWindowIcons(HWND, WORD, WORD, HWND)
  506. //
  507. //  PURPOSE: To arrage the mdi child icons.
  508. //
  509. //  PARAMETERS:
  510. //    hwnd      - The window handling the command.
  511. //    wCommand  - IDM_WINDOW_ICONS    (unused).
  512. //    wNotify   - Notification number (unused)
  513. //    hwndCtrl  - NULL                (unused).
  514. //
  515. //  RETURN VALUE:
  516. //    Always returns 0 - command handled.
  517. //
  518. //  COMMENTS:
  519. //
  520. //
  521.  
  522. #pragma argsused
  523. LRESULT CmdWindowIcons(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  524. {
  525.     SendMessage(ghwndMDIClient, WM_MDIICONARRANGE, 0, 0);
  526.  
  527.     return 0;
  528. }
  529.  
  530. //
  531. //  FUNCTION: CmdWindowCloseAll(HWND, WORD, WORD, HWND)
  532. //
  533. //  PURPOSE: To close all of the MDI child windows.
  534. //
  535. //  PARAMETERS:
  536. //    hwnd      - The window handling the command.
  537. //    wCommand  - IDM_WINDOW_CLOSEALL (unused).
  538. //    wNotify   - Notification number (unused)
  539. //    hwndCtrl  - NULL                (unused).
  540. //
  541. //  RETURN VALUE:
  542. //    Always returns 0 - command handled.
  543. //
  544. //  COMMENTS:
  545. //
  546. //
  547.  
  548. #pragma argsused
  549. #pragma warn -pia
  550. LRESULT CmdWindowCloseAll(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  551. {
  552.      HWND hwndChild;
  553.  
  554.      // As long as the MDI client has a child, destroy it
  555.      while (hwndChild = GetWindow(ghwndMDIClient, GW_CHILD))
  556.      {
  557.           // Skip the icon and title windows
  558.           while (hwndChild && GetWindow(hwndChild, GW_OWNER))
  559.                 hwndChild = GetWindow(hwndChild, GW_HWNDNEXT);
  560.  
  561.           if (IsWindow(hwndChild))
  562.                 SendMessage(ghwndMDIClient, WM_MDIDESTROY, (WPARAM)hwndChild, 0);
  563.           else
  564.                 break;
  565.      }
  566.  
  567.      return 0;
  568. }
  569. #pragma warn .pia
  570.